Bank Marketing Data Set¶
Los datos utilizados para esta práctica se pueden descargar del siguiente link. https://archive.ics.uci.edu/ml/datasets/bank+marketing
A continuación se cargan las librerías necesarias para el primer análisis
In [5]:
import os, sys
import numpy as np
import pandas as pd
import pandas_profiling ####Verificar que esté instalada. Si no está instalada, se puede utilziar el comando conda install -c conda-forge pandas-profiling --y
from IPython.display import Image
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.metrics import f1_score, roc_auc_score
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV #####Revisar esta librería.
from sklearn.neural_network import MLPClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn import tree
from sklearn.metrics import confusion_matrix
from sklearn.metrics import recall_score
from sklearn.metrics import precision_score
from sklearn.metrics import classification_report
from sklearn.ensemble import GradientBoostingClassifier
#from sklearn.externals.six import StringIO
from IPython.display import Image
from sklearn.tree import export_graphviz
#import pydotplus
#from sklearn.externals import joblib
Configuración del directorio y lectura de los datos¶
In [6]:
%cd C:\Users\USUARIO\Documents\monitoria_cda_2020_02\Clases_Python\Clase8_Python\bank-additional
In [7]:
##Importante, el archivo no está seoarada por comas, si no por punto y coma
data=pd.read_csv('bank-additional-full.csv', sep=";")
In [14]:
#######Esto es una prueba para leer los datos del parcial
#%cd C:\Users\USUARIO\Documents\monitoria_marketing\Parcial_marketing
##Codigo para leer data del parcial
#data_parcial = pd.read_excel('data_parcial.xlsx')
In [8]:
data.head()
Out[8]:
A continnuación, se detalla las primeras filas del dataframe, con el fin de verificar que el archivo esté correctamente cargado
In [20]:
data.head()
Out[20]:
A continuación, se obtiene el tipo de cada una de las variables.
In [9]:
data.dtypes
Out[9]:
Finalmente, se obtiene el tamaño del dataframe¶
In [10]:
data.shape
Out[10]:
Metodología analítica¶
In [11]:
Image(url= "https://www.ibmbigdatahub.com/sites/default/files/figure01_revised.jpg")
Out[11]:
Metodologìa ASUM.
- Entendiendo el negocio
- Acercamiento analítico
- Requerimiento de los datos
- Recolección de los datos
- Entendimiento de los datos
- Prepraraciòn de los datos
- Modelamiento.
- Evaluación
- Despliegue
- Feedback
ver referencia https://www.ibmbigdatahub.com/blog/why-we-need-methodology-data-science
Entendimiento de la data y el negocio¶
Los datos están relacionados con campañas de marketing de una institución bancaria portuguesa. Las campañas de marketing se basaron en llamadas telefónicas. A menudo, se requería más de un contacto con el mismo cliente para que el cliente se suscriba a un depósito a plazo. Por otra parte, la data que se cargó es la denominada "bank-additional-full", la cual contiene 41188 observacioes y 21 variables, y son observaciones ordenadas por fecha (de Mayo de 2008 a Noviembre de 2010), estos datos son los utilizados en [Moro et al., 2014]
Importante¶
Cada observación corresponde a un contacto con el cliente, esto es muy importante, dado que, según la descripción anterior, un cliente puede estar dos veces en la data, donde, en un contacto pudo no suscribirse y en segundo contacto si. En la siguiente ítem se analizarán las distintas variables del archivo.
Descripción de las variables.¶
Se puede observar distintos tipos de variables por ejemplo, age es numérico y representa a la edad del cliente, job o tipo de trabajo es categórco, estado civil categórico, nivel educativo categórico, por otra parte, la variable default indica si el cliente tiene créditos en mora o no y es categórica, housing indica si el cliente tiene o no vivienda y es categórica, loan indica si tiene o no préstamo y es categórica, contact indica la forma en la cual se contactó el cliente (de forma telefónica, por celular, etc), month indica el mes de contacto, day_of_week indica el día de la semana, duration indica la duración de la llamada, campaign indica la cantidad de días que pasaron después de que el cliente fue contactado por última vez desde una campaña anterior, pdays indica el número de días que han pasado desde el último contacto, esta variable es numérica, previous cantidad de contactos realizados antes de esta campaña y para este cliente, poutcome indica si la campaña anterior fue exitosa o no, la variable y indica si el cliente ha suscrito un depósito a plazo, esta variable es dicotómica.
A continuación, se realiza una revisión únicamente del primer registro.
In [12]:
data.loc[0, : ]
Out[12]:
A continuación, se realiza un primer análisis de la data utilizando la función pandas profiling.
In [13]:
pandas_profiling.ProfileReport(data)
Out[13]:
Análisis descriptivo sobre los datos previamente cargados¶
Limpieza de los datos¶
Valores missing¶
A continuación, se va estudiar si existe o no valores missing.
In [14]:
def missing_values_table(df):
mis_val = df.isnull().sum()
mis_val_percent = 100 * df.isnull().sum()/len(df)
mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
mis_val_table_ren_columns = mis_val_table.rename(
columns = {0 : 'Missing Values', 1 : '% of Total Values'})
return mis_val_table_ren_columns
In [15]:
missing_values_table(data)
Out[15]:
Como se puede observar, no existen valores missing en los datos, sin embargo, se realizará un análisis más profundo, variable por variable.
Variable age (edad)¶
In [16]:
data["age"].describe()
Out[16]:
In [17]:
data["age"].hist()
Out[17]:
Como se puede observar, la variable edad presenta valores con un rango entre 17 y 98, por otra parte, la media es 40 años, por tanto, parece ser que no hay datos "raros"
Variable job (trabajo)¶
In [18]:
## Frecuencia absoluta
#data['job'].describe()
pd.value_counts(data['job'])
Out[18]:
In [19]:
## Frecuencia relativa
100 * data['job'].value_counts() / len(data['job'])
Out[19]:
In [20]:
plot_frec_abs = data['job'].value_counts().plot(kind='bar', title='job')
Se puede observar que la variable trabajo presenta una categorìa denominada "unknown", que corresponde al 0,8% , por lo tanto, se procede a eliminar esta categoría.
In [21]:
data=data[data.job!="unknown"]
data2=data[data.job=="student"]
In [22]:
100 * data2['job'].value_counts() / len(data2['job'])
Out[22]:
Variable marital (estado civil)¶
In [23]:
## Frecuencia absoluta
pd.value_counts(data['marital'])
Out[23]:
In [24]:
## Frecuencia relativa
100 * data['marital'].value_counts() / len(data['marital'])
Out[24]:
In [25]:
plot_frec_abs = data['marital'].value_counts().plot(kind='bar', title='marital')
Se procede a eliminar la categorìa unknown de la variable marital.
In [26]:
data=data[data.job!="unknown"]
Variable education (educación)¶
In [27]:
## Frecuencia absoluta
pd.value_counts(data['education'])
Out[27]:
In [28]:
## Frecuencia relativa
100 * data['education'].value_counts() / len(data['education'])
Out[28]:
In [29]:
plot_frec_abs = data['education'].value_counts().plot(kind='bar', title='education')
Se procede a eliminar la categorìa unknown de la variable education.
In [30]:
data=data[data.education!="unknown"]
Variable default, si tiene o no tiene mora¶
In [31]:
## Frecuencia absoluta
pd.value_counts(data['default'])
Out[31]:
Esta variable no se debe utilizará para el análisis. ¿Por qué?
Variable housing (si tiene o no vivienda)¶
In [32]:
## Frecuencia absoluta
pd.value_counts(data['housing'])
Out[32]:
In [33]:
## Frecuencia relativa
100 * data['housing'].value_counts() / len(data['housing'])
Out[33]:
In [34]:
plot_frec_abs = data['housing'].value_counts().plot(kind='bar', title='housing')
Se procede a eliminar la categorìa unknown de la variable housing.
In [35]:
data=data[data.housing!="unknown"]
Variable loan (si tiene o no prestamo)¶
In [36]:
## Frecuencia absoluta
pd.value_counts(data['loan'])
Out[36]:
In [37]:
## Frecuencia relativa
100 * data['loan'].value_counts() / len(data['loan'])
Out[37]:
In [38]:
plot_frec_abs = data['loan'].value_counts().plot(kind='bar', title='loan')
Variables excluidas para la limpieza de los datos¶
Las siguientes variables fueron excludías del análisis month (mes) y duration (duración de la llamada), campaign ¿Por qué?
variable contact (tipo de contacto)¶
In [39]:
## Frecuencia absoluta
pd.value_counts(data['contact'])
Out[39]:
In [40]:
## Frecuencia relativa
100 * data['contact'].value_counts() / len(data['contact'])
Out[40]:
In [41]:
plot_frec_abs = data['contact'].value_counts().plot(kind='bar', title='contact')
Variable pdays (dìas transcurridos desde el ùltimo contacto )¶
In [42]:
data["pdays"].describe()
Out[42]:
Como s puede observar, esta variable es numérica, sin embargo, 999 es un valor que indica que el cliente nunca ha sido contactado, por otra parte, por lo menos el 75 % de los datos indican que los clientes nunca se han tocado ppreviamente, por tanto, no se utilizará esta variable para un futuro análisis, sin embargo, se utilizará la variable previous, que indica la cantidad de veces que se han contactado con el cliente previamente.
Variable previous (número de contactos previos al cliente antes de la campaña)¶
In [43]:
data["previous"].describe()
Out[43]:
In [44]:
data["previous"].hist()
Out[44]:
Variable poutcome (la campaña anterior fue exitosa o no)¶
In [45]:
## Frecuencia absoluta
pd.value_counts(data['poutcome'])
Out[45]:
In [46]:
## Frecuencia relativa
100 * data['poutcome'].value_counts() / len(data['poutcome'])
Out[46]:
In [47]:
plot_frec_abs = data['poutcome'].value_counts().plot(kind='bar', title='poutcome')
Variable target¶
In [48]:
## Frecuencia absoluta
pd.value_counts(data['y'])
Out[48]:
In [49]:
## Frecuencia relativa
100 * data['y'].value_counts() / len(data['y'])
Out[49]:
In [50]:
plot_frec_abs = data['y'].value_counts().plot(kind='bar', title='y')
Selección de variables para el análisis.¶
In [51]:
data_analisis=data.loc[:, ['age',
'job',
'marital',
'education',
'housing',
'loan',
'contact',
'previous',
'poutcome',
'y']]
Discretización de la variable edad.¶
In [52]:
###Función que permite discretizar una variable cuantitativa
def cate(x):
if x['age']<=32:
return '32'
elif x['age']>32 and x['age']<=38:
return '33-38'
elif x['age']>38 and x['age']<=47:
return '38-47'
elif x['age']>47 and x['age']<=60:
return '47-60'
else:
return '60'
##Crear una nueva variable denominada "grupo_edad"
data_analisis['grupo_edad']=data_analisis.apply(cate,axis=1)
In [53]:
##Frecuencia absoluta
pd.value_counts(data_analisis['grupo_edad'])
Out[53]:
In [54]:
## Frecuencia relativa
100 * data_analisis['grupo_edad'].value_counts() / len(data_analisis['grupo_edad'])
Out[54]:
A continuación, se construye una tabla de contigencia entre la variable grupo edad y la variable y
In [55]:
Tabla = pd.crosstab(index=data_analisis.grupo_edad,columns=data_analisis["y"],margins=True)
Tabla.index= ["32","33-38", "38-47", "47-60", "60", "Total y"] # Para las filas, pero el último elemento es el total de la "columna"
Tabla.columns= ["no", 'yes', "Total_edad"] # Para las columnas, pero el último elemento es el total de la "fila"
Tabla
Out[55]:
In [56]:
####Frecuencia relativa filas
table2 = Tabla.div(Tabla.Total_edad, axis=0)
table2
Out[56]:
In [57]:
colors_list = ['#5cb85c','#5bc0de','#d9534f']
# Change this line to plot percentages instead of absolute values
ax = (table2[["no", "yes"]]).plot(kind='bar',figsize=(15,4),width = 0.8,color = colors_list,edgecolor=None)
plt.legend(labels=Tabla.columns,fontsize= 14)
plt.title("Porcentaje de aceptación por edad",fontsize= 16)
plt.xticks(fontsize=14)
for spine in plt.gca().spines.values():
spine.set_visible(False)
plt.yticks([])
# Add this loop to add the annotations
for p in ax.patches:
width, height = p.get_width(), p.get_height()
x, y = p.get_xy()
ax.annotate('{:.0%}'.format(height), (x, y + height + 0.01))
Qué conclusiones y que acciones puede obtener del gráfico anterior?¶
Se pede pensar en realizar una campaña enfocada a las personas mayor a 60 años.
Análisis con relación a la variable job¶
In [58]:
Tabla = pd.crosstab(index=data_analisis.job,columns=data_analisis["y"],margins=True)
Tabla.index= ['admin',
'blue-collar',
'entrepreneur',
'housemaid',
'management',
'retired',
'self-employed',
'services',
'student',
'technician',
'unemployed', "Total y"] # Para las filas, pero el último elemento es el total de la "columna"
Tabla.columns= ["no", 'yes', "Total_job"] # Para las columnas, pero el último elemento es el total de la "fila"
Tabla
Out[58]:
In [59]:
####Frecuencia relativa filas
table2 = Tabla.div(Tabla.Total_job, axis=0)
table2
Out[59]:
In [60]:
colors_list = ['#5cb85c','#5bc0de','#d9534f']
# Change this line to plot percentages instead of absolute values
ax = (table2[["no", "yes"]]).plot(kind='bar',figsize=(25,5),width = 0.8,color = colors_list,edgecolor=None)
plt.legend(labels=Tabla.columns,fontsize= 14)
plt.title("Porcentaje de aceptación por edad",fontsize= 16)
plt.xticks(fontsize=14)
for spine in plt.gca().spines.values():
spine.set_visible(False)
plt.yticks([])
# Add this loop to add the annotations
for p in ax.patches:
width, height = p.get_width(), p.get_height()
x, y = p.get_xy()
ax.annotate('{:.0%}'.format(height), (x, y + height + 0.01))
Qué conclusiones y que acciones puede obtener del gráfico anterior?¶
Se puede pensar en realziar campañas enfocadas hacia los estudiantes y los retirados.
Análisis con relación a la variable tipo de contacto (contact)¶
In [61]:
Tabla = pd.crosstab(index=data_analisis.contact,columns=data_analisis["y"],margins=True)
Tabla.index= ["cellular","telephone", "Total y"] # Para las filas, pero el último elemento es el total de la "columna"
Tabla.columns= ["no", 'yes', "Total_contact"] # Para las columnas, pero el último elemento es el total de la "fila"
Tabla
Out[61]:
In [62]:
####Frecuencia relativa filas
table2 = Tabla.div(Tabla.Total_contact, axis=0)
table2
Out[62]:
In [63]:
colors_list = ['#5cb85c','#5bc0de','#d9534f']
# Change this line to plot percentages instead of absolute values
ax = (table2[["no", "yes"]]).plot(kind='bar',figsize=(15,4),width = 0.8,color = colors_list,edgecolor=None)
plt.legend(labels=Tabla.columns,fontsize= 14)
plt.title("Porcentaje de aceptación por edad",fontsize= 16)
plt.xticks(fontsize=14)
for spine in plt.gca().spines.values():
spine.set_visible(False)
plt.yticks([])
# Add this loop to add the annotations
for p in ax.patches:
width, height = p.get_width(), p.get_height()
x, y = p.get_xy()
ax.annotate('{:.0%}'.format(height), (x, y + height + 0.01))
Qué conclusiones y que acciones puede obtener del gráfico anterior?¶
Se puede pensar en realziar campañas enfocadas hacia los clientes que tienen celular. Por telefono nno responden mucho.
Análisis con relación a la variable loan (si tiene crédito o no)¶
In [64]:
Tabla = pd.crosstab(index=data_analisis.loan,columns=data_analisis["y"],margins=True)
Tabla.index= ["no","yes", "Total y"] # Para las filas, pero el último elemento es el total de la "columna"
Tabla.columns= ["no", 'yes', "Total_loan"] # Para las columnas, pero el último elemento es el total de la "fila"
Tabla
Out[64]:
In [65]:
####Frecuencia relativa filas
table2 = Tabla.div(Tabla.Total_loan, axis=0)
table2
Out[65]:
In [66]:
colors_list = ['#5cb85c','#5bc0de','#d9534f']
# Change this line to plot percentages instead of absolute values
ax = (table2[["no", "yes"]]).plot(kind='bar',figsize=(15,4),width = 0.8,color = colors_list,edgecolor=None)
plt.legend(labels=Tabla.columns,fontsize= 14)
plt.title("Porcentaje de aceptación por edad",fontsize= 16)
plt.xticks(fontsize=14)
for spine in plt.gca().spines.values():
spine.set_visible(False)
plt.yticks([])
# Add this loop to add the annotations
for p in ax.patches:
width, height = p.get_width(), p.get_height()
x, y = p.get_xy()
ax.annotate('{:.0%}'.format(height), (x, y + height + 0.01))
Analizando el gráfico anterior, se puede observar que la variable loan no influye sobre el porcentaje de aceptación a la campaña.
Tratamiento de datos para construir distintos modelos de clasificación¶
In [67]:
##Eliminar la variable grupo_edad
del data_analisis['grupo_edad']
data_analisis.head()
Out[67]:
A continuación, se redefine la variable y de la siguiente forma:
In [68]:
###Función que permite discretizar una variable cuantitativa
def cate(x):
if x['y']=="yes":
return 1
else:
return '0'
##Crear una nueva variable denominada "grupo_edad"
data_analisis['target']=data_analisis.apply(cate,axis=1)
In [69]:
pd.value_counts(data_analisis["target"])
Out[69]:
In [70]:
del data_analisis["y"]
In [71]:
data_analisis.dtypes
Out[71]:
In [72]:
data_analisis['target'] = data_analisis['target'].astype(int)
A continuación se realizar una selección aleatoria de datos de entrenamiento, validación y test. *¶
Convertir variables categóricas a dummies.
In [73]:
data_model = pd.get_dummies(data_analisis)
In [74]:
data_model.dtypes
Out[74]:
Para cambiar el orden de las variables.
In [75]:
columnsTitles = ["age",
"previous",
"job_admin.",
"job_blue-collar",
"job_entrepreneur",
"job_housemaid",
"job_management",
"job_retired" ,
"job_self-employed",
"job_services",
"job_student",
"job_technician",
"job_unemployed",
"marital_divorced",
"marital_married",
"marital_single",
"marital_unknown",
"education_basic.4y",
"education_basic.6y",
"education_basic.9y",
"education_high.school",
"education_illiterate",
"education_professional.course",
"education_university.degree",
"housing_no",
"housing_yes",
"loan_no",
"loan_yes",
"contact_cellular",
"contact_telephone",
"poutcome_failure",
"poutcome_nonexistent",
"poutcome_success",
"target"]
data_model = data_model.reindex(columns=columnsTitles)
In [76]:
data_model.dtypes
Out[76]:
A continuación, se realiza una partición sobre la data.
In [77]:
###Partición de la data sobre entrenamiento y validacion.
X, y = data_model.iloc[:,0:33],data_model.iloc[:,33:34]
##Selección data de entrenamiento y test
X_train, X_test_pre, y_train, y_test_pre = train_test_split(X, y, test_size=0.3, random_state=3)
##Selección data de test y developer para tunnear los hiperparámetros
X_dev, X_test, Y_dev, Y_test = train_test_split(X_test_pre, y_test_pre, test_size=0.5, random_state=3)
Árboles de decisión¶
Para obtener los hiperparámetros de un modelo basado en árboles de decisión¶
In [81]:
def eval_model(X_train, y_train, X_test, y_test):
"""
Función para obtener los hiperparámetros del modelo árboles de decisión
Parámetros: Recibe como parámetros los datos de entrenamiento y los datos de desarrollo.
únicamente encuentra la mejor combinaciones de los marámetros max depth, mas features,
max_depth, max_features.
"""
vector_n_estimators=[1] ## No es un parametro
lr_list = [1] # No se va considerar
vector_max_depth=[1, 2, 3, 4, 5, ] ##si es un parámetro
max_features=[9, 12, 14] ##si es un parametro
for r in lr_list:
for p in vector_max_depth:
for f in max_features:
for e in vector_n_estimators:
#alg = DecisionTreeClassifier(criterion = "entropy",
# random_state = 100,
# max_depth=30, min_samples_leaf=5)
#criterion{“gini”, “entropy”}, default=”gini”
alg = DecisionTreeClassifier(#n_estimators=e,
#learning_rate=r,
max_features=f,
max_depth=p,
random_state=0)
##Inicio del entrenamiento
alg.fit(X_train, y_train)
# Para comenzar con la prediccion sobre test
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
# Para comenzar con la predicción sobre train
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
dif_accuracy = abs(metrics.f1_score(y_train, predictions_train) - metrics.f1_score(y_test, predictions))
##Para imprimer las predicciones sobre cada combinación de hiperparámetros.
print("#####################################")
print("max_depth: ", p, "max_features: ", f)
print("#####################################")
print("f1_score sobre datos de train")
print(metrics.f1_score(y_train, predictions_train))
print('f1_score sobre datos de desarrollo')
print(metrics.f1_score(y_test, predictions))
print("Diferencia entre el f1_score obtenido en test y desarrollo")
print(dif_accuracy)
##Para aplicar la fución anterior.
eval_model(X_train, y_train, X_dev, Y_dev)
Importante:¶
Los mejores hiperparámetros encontrados son cuando max_depth = 5 y max features = 14, entonces, se utiliza este modelo, dado que la métrica que consideramos para este ejercicio es el f1 score.
Función para estimar el modelo basado en árboles con los hiperparámetros seleccionados y aplicarlos sobre la data de test¶
In [82]:
def tree_classifier(X_train, X_test, y_train, y_test):
"""
Función para estimar un modelo utilizando árboles de decisión
Esta funciòn recibe como parametros los datos de entrenamiento y de test
Finalmente, imprime el AUC, f1-score, precision, recall, accuracy
por cada clase, tanto para la data de entrenamiento, como la de test.
Finaalmente, esta función también imprime la importancia de las variables.
"""
alg = DecisionTreeClassifier(#n_estimators=e,
#learning_rate=r,
max_features=14,
max_depth=5,
random_state=0)
# Entrenamiento
print('Inicio entrenamiento')
alg.fit(X_train, y_train)
# Guardar el modelo en disco en el siguiente directorio
# save the model to disk
#%cd C:\Users\\USUARIO\\Documents\\Monitoria_cda_2019_2\\Clases_Python\\Clase8_Python
#filename = 'finalized_model.sav'
#joblib.dump(alg, filename)
# Para comenzar con la prediccion
print("Iniciar la predicciòn")
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
#Para imprimir las metricas al aplicar el modelo sobre los datos de train
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de train ")
print("Accuracy sobtr train")
print(metrics.accuracy_score(y_train, predictions_train))
print("AUC sobre train")
print(metrics.roc_auc_score(y_train, pred_proba_train))
print("Matriz de confusion sobre train")
print(confusion_matrix(y_train, predictions_train))
print("Recall sobre train")
print(metrics.recall_score(y_train, predictions_train))
print("Precision sobre train")
print(metrics.precision_score(y_train, predictions_train))
print("f1-Score sobre train")
print( metrics.f1_score(y_train, predictions_train))
print("Reporte clasificación sobre train")
print(classification_report(y_train, predictions_train))
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de test ")
print("Accuracy sobre test")
print(metrics.accuracy_score(y_test, predictions))
print("AUC sobre test")
print(metrics.roc_auc_score(y_test, pred_proba))
print("Matriz de confusion sobre test")
print(confusion_matrix(y_test, predictions))
print("Recall sobre test")
print(metrics.recall_score(y_test, predictions))
print("Precision sobre test")
print(metrics.precision_score(y_test, predictions))
print("f1-Score sobre test")
print( metrics.f1_score(y_test, predictions))
print("Reporte clasificación sobre test")
print(classification_report(y_test, predictions))
feat_imp = alg.feature_importances_
feat = X_train.columns.tolist()
# clf.best_estimator_.booster().get_fscore()
res_df = pd.DataFrame({'Features': feat, 'Importance': feat_imp}).sort_values(by='Importance', ascending=False)
res_df.plot('Features',
'Importance',
kind='bar',
title='Feature Importances',
color= "blue")
plt.ylabel('Feature Importance Score')
plt.show()
print(res_df)
print(res_df["Features"].tolist())
tree_classifier(X_train, X_test, y_train, Y_test)
Random Forest¶
Para obtener los hiperparámetros de un modelo random forest¶
In [84]:
def eval_model(X_train, y_train, X_test, y_test):
"""
Función para obtener los hiperparámetros del modelo random forest.
Parámetros: Recibe como parámetros los datos de entrenamiento y los datos de desarrollo.
únicamente encuentra la mejor combinaciones de los marámetros n_estimators, learning_rate,
max_depth, max_features.
"""
vector_n_estimators=[40, 60, 100] ## si va
lr_list = [1] ## No va
vector_max_depth=[3, 6, 9] ## si va
max_features=[9, 12, 14] ## si va
for r in lr_list:
for p in vector_max_depth:
for f in max_features:
for e in vector_n_estimators:
alg = RandomForestClassifier(n_estimators=e,
#learning_rate=r,
max_features=f,
max_depth=p,
random_state=0)
##Inicio del entrenamiento
alg.fit(X_train, y_train)
# Para comenzar con la prediccion sobre test
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
# Para comenzar con la predicción sobre train
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
dif_accuracy = abs(metrics.f1_score(y_train, predictions_train) - metrics.f1_score(y_test, predictions))
##Para imprimer las predicciones sobre cada combinación de hiperparámetros.
print("#####################################")
print("max_depth: ", p, "max_features: ", f, "n_estimators: ", e)
print("#####################################")
print("f1_score sobre datos de train")
print(metrics.f1_score(y_train, predictions_train))
print('f1_score sobre datos de desarrollo')
print(metrics.f1_score(y_test, predictions))
print("Diferencia entre el f1_score obtenido en test y desarrollo")
print(dif_accuracy)
##Para aplicar la fución anterior.
eval_model(X_train, y_train, X_dev, Y_dev)
Importante¶
Los mejores hiperparámetros para el random forest son: max_depth: 9 max_features: 12 n_estimators: 100
Función para estimar el modelo basado en random forest con los hiperparámetros seleccionados y aplicarlos sobre la data de test¶
In [85]:
def tree_classifier(X_train, X_test, y_train, y_test):
"""
Función para estimar un modelo utilizando random forest
Esta funciòn recibe como parametros los datos de entrenamiento y de test
Finalmente, imprime el AUC, f1-score, precision, recall, accuracy
por cada clase, tanto para la data de entrenamiento, como la de test.
Finaalmente, esta función también imprime la importancia de las variables.
"""
alg = RandomForestClassifier(n_estimators=100,
#learning_rate=r,
max_features=12,
max_depth=9,
random_state=0)
# Entrenamiento
print('Inicio entrenamiento')
alg.fit(X_train, y_train)
# Guardar el modelo en disco en el siguiente directorio
# save the model to disk
#%cd C:\Users\\USUARIO\\Documents\\Monitoria_cda_2019_2\\Clases_Python\\Clase8_Python
#filename = 'finalized_model.sav'
#joblib.dump(alg, filename)
# Para comenzar con la prediccion
print("Iniciar la predicciòn")
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
#Para imprimir las metricas al aplicar el modelo sobre los datos de train
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de train ")
print("Accuracy sobtr train")
print(metrics.accuracy_score(y_train, predictions_train))
print("AUC sobre train")
print(metrics.roc_auc_score(y_train, pred_proba_train))
print("Matriz de confusion sobre train")
print(confusion_matrix(y_train, predictions_train))
print("Recall sobre train")
print(metrics.recall_score(y_train, predictions_train))
print("Precision sobre train")
print(metrics.precision_score(y_train, predictions_train))
print("f1-Score sobre train")
print( metrics.f1_score(y_train, predictions_train))
print("Reporte clasificación sobre train")
print(classification_report(y_train, predictions_train))
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de test ")
print("Accuracy sobre test")
print(metrics.accuracy_score(y_test, predictions))
print("AUC sobre test")
print(metrics.roc_auc_score(y_test, pred_proba))
print("Matriz de confusion sobre test")
print(confusion_matrix(y_test, predictions))
print("Recall sobre test")
print(metrics.recall_score(y_test, predictions))
print("Precision sobre test")
print(metrics.precision_score(y_test, predictions))
print("f1-Score sobre test")
print( metrics.f1_score(y_test, predictions))
print("Reporte clasificación sobre test")
print(classification_report(y_test, predictions))
feat_imp = alg.feature_importances_
feat = X_train.columns.tolist()
# clf.best_estimator_.booster().get_fscore()
res_df = pd.DataFrame({'Features': feat, 'Importance': feat_imp}).sort_values(by='Importance', ascending=False)
res_df.plot('Features',
'Importance',
kind='bar',
title='Feature Importances',
color= "blue")
plt.ylabel('Feature Importance Score')
plt.show()
print(res_df)
print(res_df["Features"].tolist())
tree_classifier(X_train, X_test, y_train, Y_test)
Gradient Boosting¶
Función para obtener los hiperparámetros de un modelo gradient boosting¶
In [86]:
def eval_model(X_train, y_train, X_test, y_test):
"""
Función para obtener los hiperparámetros del modelo gradient boosting.
Parámetros: Recibe como parámetros los datos de entrenamiento y los datos de desarrollo.
únicamente encuentra la mejor combinaciones de los marámetros n_estimators, learning_rate,
max_depth, max_features.
"""
vector_n_estimators=[40, 80, 100]
lr_list = [0.3]
vector_max_depth=[3, 5]
max_features=[9, 12]
for r in lr_list:
for p in vector_max_depth:
for f in max_features:
for e in vector_n_estimators:
alg = GradientBoostingClassifier(n_estimators=e,
learning_rate=r,
max_features=f,
max_depth=p,
random_state=0)
##Inicio del entrenamiento
alg.fit(X_train, y_train)
# Para comenzar con la prediccion sobre test
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
# Para comenzar con la predicción sobre train
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
dif_accuracy = abs(metrics.f1_score(y_train, predictions_train) - metrics.f1_score(y_test, predictions))
##Para imprimer las predicciones sobre cada combinación de hiperparámetros.
print("#####################################")
print("learning_rate: ", r , "max_depth: ", p, "max_features: ", f, "n_estimators: ", e)
print("f1_score sobre datos de train")
print(metrics.f1_score(y_train, predictions_train))
print('f1_score sobre datos de desarrollo')
print(metrics.f1_score(y_test, predictions))
print("Diferencia entre el f1_score obtenido en test y desarrollo")
print(dif_accuracy)
##Para aplicar la fución anterior.
eval_model(X_train, y_train, X_dev, Y_dev)
Importante¶
Los mejores hiperparámetros son learning_rate: 0.3 max_depth: 5 max_features: 12 n_estimators: 40
Función para estimar el modelo basado en gradient boosting y aplicarlo sobre los datos de test.¶
In [89]:
def xgb_classifier(X_train, X_test, y_train, y_test):
"""
Función para estimar un modelo utilizando gradient boosting machine (esemble)
Esta funciòn recibe como parametros los datos de entrenamiento y de test
Finalmente, imprime el AUC, f1-score, precision, recall, accuracy
por cada clase, tanto para la data de entrenamiento, como la de test.
Finaalmente, esta función también imprime la importancia de las variables.
"""
alg = GradientBoostingClassifier(n_estimators=40,
learning_rate=0.3,
max_features=12,
max_depth=5, random_state=0)
# Entrenamiento
print('Inicio entrenamiento')
alg.fit(X_train, y_train)
# Guardar el modelo en disco en el siguiente directorio
# save the model to disk
#%cd C:\Users\\USUARIO\\Documents\\Monitoria_cda_2019_2\\Clases_Python\\Clase8_Python
#filename = 'finalized_model.sav'
#joblib.dump(alg, filename)
# Para comenzar con la prediccion
print("Iniciar la predicciòn")
predictions = alg.predict(X_test)
pred_proba = alg.predict_proba(X_test)[:, 1]
predictions_train = alg.predict(X_train)
pred_proba_train = alg.predict_proba(X_train)[:, 1]
#Para imprimir las metricas al aplicar el modelo sobre los datos de train
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de train ")
print("Accuracy sobtr train")
print(metrics.accuracy_score(y_train, predictions_train))
print("AUC sobre train")
print(metrics.roc_auc_score(y_train, pred_proba_train))
print("Matriz de confusion sobre train")
print(confusion_matrix(y_train, predictions_train))
print("Recall sobre train")
print(metrics.recall_score(y_train, predictions_train))
print("Precision sobre train")
print(metrics.precision_score(y_train, predictions_train))
print("f1-Score sobre train")
print( metrics.f1_score(y_train, predictions_train))
print("Reporte clasificación sobre train")
print(classification_report(y_train, predictions_train))
# Para imprimir las métricas al aplicar el modelo sobre los datos de test
print("Metricas al aplicar el modelo sobre los datos de test ")
print("Accuracy sobre test")
print(metrics.accuracy_score(y_test, predictions))
print("AUC sobre test")
print(metrics.roc_auc_score(y_test, pred_proba))
print("Matriz de confusion sobre test")
print(confusion_matrix(y_test, predictions))
print("Recall sobre test")
print(metrics.recall_score(y_test, predictions))
print("Precision sobre test")
print(metrics.precision_score(y_test, predictions))
print("f1-Score sobre test")
print( metrics.f1_score(y_test, predictions))
print("Reporte clasificación sobre test")
print(classification_report(y_test, predictions))
feat_imp = alg.feature_importances_
feat = X_train.columns.tolist()
# clf.best_estimator_.booster().get_fscore()
res_df = pd.DataFrame({'Features': feat, 'Importance': feat_imp}).sort_values(by='Importance', ascending=False)
res_df.plot('Features',
'Importance',
kind='bar',
title='Feature Importances',
color= "blue")
plt.ylabel('Feature Importance Score')
plt.show()
print(res_df)
print(res_df["Features"].tolist())
In [90]:
xgb_classifier(X_train, X_test, y_train, Y_test)
Laboratorio para entregar¶
Puntos asociados al laboratorio 7¶
- ¿Qué clase de algoritmo implementa sklearn? ¿CHAID o ID3?
- ¿Que otros hiperparámetros utilizan los árboles de decisión? ¿Para que sirve cada uno?
Puntos asociados al laboratorio 8¶
- Teniendo en cuenta los resultados de los modelos basados en árboles de decisión, random forest y gradient boosting ¿cuál modelo seleccionaría usted? justifica su respuesta.
- ¿Cómo utilizaría el modelo seleccionado para una futura campaña de venta de productos?
Puntos adicionales -> Opcional.¶
- Investigar cómo interpretar los modelos de "caja negra", para ello, puede consultar los singuientes links. https://www.explorium.ai/blog/interpretability-and-explainability-part-1/ https://www.explorium.ai/blog/interpretability-and-explainability-part-2/
- Para el modelo seleccionado, pinte un gráfico de dependencia parcial para las variables más importantes e interprete los resultados.
- Para el modelo seleccionado, pinte un gráfico de para estudiar los Shapley Values.
In [ ]: